Java多线程----java 对象锁

最新推荐文章于 2024-09-04 12:58:12 发布
最新推荐文章于 2024-09-04 12:58:12 发布
阅读量3.3w 收藏 34
点赞数 4
分类专栏： Java 文章标签： 多线程 java thread class object 任务

      在并发环境下，解决共享资源冲突问题时，可以考虑使用锁机制。

1. 对象锁

      所有对象都自动含有单一的锁。
     JVM负责跟踪对象被加锁的次数。如果一个对象被解锁，其计数变为0。在任务（线程）第一次给对象加锁的时候，计数变为1。每当这个相同的任务（线程）在此对象上获得锁时，计数会递增。
     只有首先获得锁的任务（线程）才能继续获取该对象上的多个锁。
     每当任务离开一个synchronized方法，计数递减，当计数为0的时候，锁被完全释放，此时别的任务就可以使用此资源。

2. 类锁

      对于同步静态方法/静态变量互斥体，由于一个class不论被实例化多少次，其中的静态方法和静态变量在内存中都只由一份。所以，一旦一个静态的方法被申明为synchronized。此类所有的实例化对象在调用此方法，共用同一把锁，我们称之为类锁。一旦一个静态变量被作为synchronized block的互斥体。进入此同步区域时，都要先获得此静态变量的对象锁。

      由上述同步静态方法引申出一个概念，那就是类锁。其实系统中并不存在什么类锁。当一个同步静态方法被调用时，系统获取的其实就是代表该类的类对象的对象锁

      可以尝试用以下方式获取类锁

synchronized (xxx.class) {...}

synchronized (Class.forName("xxx")) {...}
       若要同时获取两种锁，同时获取类锁和对象锁是允许的，并不会产生任何问题，但使用类锁时一定要注意，一旦产生类锁的嵌套获取的话，就会产生死锁，因为每个class在内存中都只能生成一个Class实例对象。

3. synchronized同步块

3.1. 同步到单一对象锁

        当使用同步块时，如果方法下的同步块都同步到一个对象上的锁，则所有的任务（线程）只能互斥的进入这些同步块。
        Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，虽然这些同步块处在不同的方法中，但由于是同步到同一个对象（当前对象 synchronized (this)），所以对它们的方法依然是互斥的。
Resource1.java

package com.zj.lock;
import java.util.concurrent.TimeUnit;
 
public class Resource1 {
    public void f() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in f()");
       synchronized (this) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in f()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public void g() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in g()");
       synchronized (this) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in g()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public void h() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in h()");
       synchronized (this) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in h()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public static void main(String[] args) {
       final Resource1 rs = new Resource1();
 
       new Thread() {
           public void run() {
              rs.f();
           }
       }.start();
 
       new Thread() {
           public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()

3.2. 同步到多个对象锁

        Resource1.java演示了三个线程（包括main线程）试图进入某个类的三个不同的方法的同步块中，这些同步块处在不同的方法中，并且是同步到三个不同的对象（synchronized (this)，synchronized(syncObject1)，synchronized (syncObject2)），所以对它们的方法中的临界资源访问是独立的。
Resource2.java

package com.zj.lock;
import java.util.concurrent.TimeUnit;
 
public class Resource2 {
    private Object syncObject1 = new Object();
    private Object syncObject2 = new Object();
 
    public void f() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in f()");
       synchronized (this) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in f()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public void g() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in g()");
       synchronized (syncObject1) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in g()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public void h() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in h()");
       synchronized (syncObject2) {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in h()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       }
    }
 
    public static void main(String[] args) {
       final Resource2 rs = new Resource2();
 
       new Thread() {
           public void run() {
              rs.f();
           }
       }.start();
 
       new Thread() {
           public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()

4. Lock对象锁

      除了使用synchronized外，还可以使用Lock对象来创建临界区。Resource3.java的演示效果同Resource1.java；Resource4.java的演示效果同Resource2.java。
Resource3.java

package com.zj.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Resource3 {
    private Lock lock = new ReentrantLock();
 
    public void f() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in f()");
       lock.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in f()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock.unlock();
       }
    }
 
    public void g() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in g()");
       lock.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in g()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock.unlock();
       }
    }
 
    public void h() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in h()");
       lock.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in h()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock.unlock();
       }
    }
 
    public static void main(String[] args) {
       final Resource3 rs = new Resource3();
 
       new Thread() {
           public void run() {
              rs.f();
           }
       }.start();
 
       new Thread() {
           public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
Thread-1:not synchronized in g()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
Thread-0:synchronized in f()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()
Thread-1:synchronized in g()

Resource4.java

package com.zj.lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
public class Resource4 {
    private Lock lock1 = new ReentrantLock();
    private Lock lock2 = new ReentrantLock();
    private Lock lock3 = new ReentrantLock();
 
    public void f() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in f()");
       lock1.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in f()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock1.unlock();
       }
    }
 
    public void g() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in g()");
       lock2.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in g()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock2.unlock();
       }
    }
 
    public void h() {
       // other operations should not be locked...
       System.out.println(Thread.currentThread().getName()
              + ":not synchronized in h()");
       lock3.lock();
       try {
           for (int i = 0; i < 5; i++) {
              System.out.println(Thread.currentThread().getName()
                     + ":synchronized in h()");
              try {
                  TimeUnit.SECONDS.sleep(3);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
           }
       } finally {
           lock3.unlock();
       }
    }
 
    public static void main(String[] args) {
       final Resource4 rs = new Resource4();
 
       new Thread() {
           public void run() {
              rs.f();
           }
       }.start();
 
       new Thread() {
           public void run() {
              rs.g();
           }
       }.start();
 
       rs.h();
    }
}
结果：
Thread-0:not synchronized in f()
Thread-0:synchronized in f()
main:not synchronized in h()
main:synchronized in h()
Thread-1:not synchronized in g()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()
Thread-1:synchronized in g()
Thread-0:synchronized in f()
main:synchronized in h()

Thread-1:synchronized in g()

     另外，ReentrantLock可定时和可轮询的锁获取模式由tryLock方法实现。

public boolean tryLock(); //等同于tryLock(0, TimeUnit.SECONDS),不停询问是否可获取锁
public boolean tryLock(long timeout,
                       TimeUnit unit)
                throws InterruptedException    //timeout - 等待锁的时间,unit - timeout 参数的时间单位

5. synchronized和lock的区别:

      Lock 的锁定是通过代码实现的，而 synchronized 是在 JVM 层面上实现的。

      synchronized 在锁定时如果方法块抛出异常，JVM 会自动将锁释放掉，不会因为出了异常没有释放锁造成线程死锁。但是 Lock 的话就享受不到 JVM 带来自动的功能，出现异常时必须在 finally 将锁释放掉，否则将会引起死锁。

      在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。

      ReentrantLock:

      ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。

      Atomic:

      和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。

      关于synchronized和lock的详细区别请看http://www.ibm.com/developerworks/cn/java/j-jtp10264/index.html

Java多线程--多个对象多个锁
吴晓如
06-04 3999
上一篇博客中介绍了多个线程同时访问一个对象，产生一个对象锁，属于同步访问，现在介绍下如果是访问多个对象，会怎么执行那？ Demo: HasSelfPrivateNum类： public class HasSelfPrivateNum { private int num=0; synchronized public void addI(String username){ ...
Java多线程--创建多线程的基本方式二：实现Runnable接口
人生得意须尽欢
01-25 2402
Java多线程--创建多线程的基本方式二：实现Runnable接口
java多线程的条件对象和锁对象demo
08-16
利用锁对象和条件对象实现了对线程的控制，具体的讲解可以参考我的博客
java线程锁方法和锁对象_Java 多线程之哪个对象才是锁？
weixin_35133814的博客
02-17 321
问题背景在感觉正常的使用ArrayList的迭代删除的操作的时候，发现了如下的崩溃日志：Causedby:java.util.ConcurrentModificationExceptionatjava.util.ArrayList$Itr.remove(ArrayList.java:846)产生上述崩溃的代码如下：Iteratoriterator=strs.iterator();whi...
Synchronized详解
最新发布
qq_50839597的博客
09-04 1702
在JVM中，monitorenter和monitorexit字节码都是依赖于底层操作系统的Mutex Lock实现的，需用将当前线程挂起，并从用户态切换到内核态，这个过程的代价非常昂贵，然后实际情况是，很多时候同步方法都运行在无锁竞争的单线程的情况下，每次再调用操作系统就得不偿失了。如果持有锁的线程很快就释放了锁，那么自旋的效率就非常好，反之，自旋的线程就会白白消耗掉处理的资源，这样反而会带来性能上的浪费。如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程，当到达全局安全点，获得偏向锁的线程被挂起，
java 多线程锁
weixin_41636858的博客
06-07 105
java多线程锁
java多线程同步之对象锁区分
陈俊的马蹄印
04-21 536
     多线程同步：多个线程共同协作正确的执行任务。     我们经常见到多线程同步关键字synchronized，那它到底是利用谁做同步锁呢。     要想实现多线程同步，必须要保证同步锁是共享唯一的。     synchronized一般用于3中场景:     1.非静态方法     2.静态方法     3.代码块一、非静态方法      同步锁指当前方法所在的对象实例，如果对象是单例，则...
多线程中的锁
qq_66292058的博客
03-13 1710
在了解什么是锁之前，我们先来看一下这样一段代码//创建变量i//我们创建两个线程,分别让i自增10000次j < 10000;j++) {i++;});j < 10000;j++) {i++;});t1.start();t2.start();try {//等待两个线程执行完成t2.join();t1.join();//打印i的值按照正常的逻辑，两个线程都让i自增了10000次，i最终的结果应该是20000才对，但事实真是如此吗？我们来看一下代码的运行结果。
Java多线程-同步机制解决线程安全问题方式一：同步代码块
01-29
Java多线程编程中，线程安全问题是常见的挑战，特别是在并发环境下，多个线程可能会同时访问和修改同一份共享资源，导致数据不一致。为了解决这个问题，Java提供了同步机制，其中一种常用的方式就是同步代码块...
JAVA线程高级-线程按序交替执行
11-01
在Java编程中，多线程是并发编程的重要组成部分，它允许程序同时执行多个任务，从而提高了系统的效率和响应性。然而，在某些场景下，我们可能需要控制线程的执行顺序，确保它们按照特定的顺序交替运行，这在并发编程...
Java多线程 - 锁
GuoXuan_CHN的博客
03-28 6700
Java多线程 - 锁 三性 可见性 指的是线程之间的可见性，一个线程对状态的修改，对其他线程是可见的。在 Java中 volatile、synchronized 和 final 实现可见性。 原子性 如果一个操作是不可分割的，我们则称之为原子操作，也就是有原子性。比如i++，就不是原子操作。在Java 中 synchronized和在lock、unlock 中操作保证原子性 有序性 一系列操作是按照规定的顺序发生的。如果在本线程之内观察，所有的操作都是有序的，如果在其他线程观察，所有的操作都是
Java多线程之对象锁及类锁
weixin_42505381的博客
12-07 817
Java面经-多线程
java线程对象锁_java多线程中的类锁和对象锁
weixin_36082346的博客
02-15 215
/***@Title Test.java*@description TODO*@time 2020年11月11日 上午8:59:22*@version 1.0**/package org.thedatamanager.hhgBigScreen;/****/public class Student{private int id;private static String school;private...
Java多线程锁
zhshx19900318的博客
03-01 832
Java 多线程中的锁机制是保证线程安全的重要手段之一，通过使用锁机制，可以控制线程的执行顺序，避免线程之间的竞争条件和死锁等问题。本文将介绍 Java 中的多线程锁机制，包括基本概念、使用方式和实例代码等。1. 基本概念在 Java 中，锁机制主要有两种类型：synchronized 和 ReentrantLock。其中，synchronized 是一种基于 JVM 实现的锁机制，可以在代码块或方法上使用，而 ReentrantLock 是一种基于 API 实现的锁机制，提供了更多的灵活性和控制能力。
多线程（14）对象锁和类锁
qq_43012298的博客
03-27 1384
对象锁（Instance Lock）和类锁（Class Lock）是在Java中用于线程同步的两种机制，它们是用来解决多线程中的并发问题，确保线程安全的重要手段。本文将详细探讨这两种锁的概念、作用、实现方式以及它们在实际编程中的应用。
【Java并发编程】偏向锁/轻量级锁/重量级锁详解
叉烧钵钵鸡的博客
06-26 1586
深入解析了 Java 并发编程中的三种锁机制：偏向锁、轻量级锁和重量级锁。文章首先介绍了锁升级模型，然后详细解释了每种锁的工作原理、加锁和解锁过程，以及它们之间的转换条件。最后，文章分析了重量级锁的实现细节，包括 Monitor 的结构和操作过程。
Java锁对象
weixin_43374578的博客
11-20 2036
1.2 Mark Word 3.3 锁膨胀 在尝试轻量级加锁时，cas无法成功 可能因为：其他线程为此对象加上了轻量级锁(有竞争)，这时进行锁膨胀，锁变为重量级锁 轻量级锁没有阻塞机制，重量级锁有阻塞机制 3.4 自旋优化-重量级锁 4. 锁消除 4.1 消除 4.2 逃逸分析 如果锁对象可能逃逸，那么就不会进行锁优化 5. 锁粒度细化 5.1 单锁 一间屋子两个功能：睡觉，学习，互不影响(不同的方法不会访问同一个资源) 如果用一个屋子(一个对象锁)的话，并发度很低 5.2
java多线程（并发）夯实之路-synchronized深入浅出
qq_61282807的博客
01-10 505
synchronized：俗称对象锁，它采用互斥的方式，使得同一时刻最多只能有一个线程持有对象锁，其他对象想要获取对象锁就只能进入阻塞状态（注意必须使用相同的锁）。 在加了锁的线程中，只有获取了锁的线程能够运行
Java中Java对象结构和各种类型锁的理解
上善若泪
12-05 1191
文章目录1 Java对象结构1.1 对象结构概述1.2 对象头1.3 实例数据1.4 对齐填充1.5 对象大小计算1.6 HotSpot对象模型2 Java中锁类型2.1 锁基础理解2.1.1 锁类型2.1.1.1 乐观锁2.1.1.2 悲观锁2.1.2 java线程阻塞的代价2.1.3 markword2.2 Java中锁2.2.1 偏向锁2.2.1.1 概念2.2.1.2 偏向锁的实现2.2.1.3 偏向锁的适用场景2.2.1.4 查看停顿–安全点停顿日志2.2.1.5 jvm开启/关闭偏向锁2.2.2
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值